package com.demo.java.OD601_650.OD638;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;

/**
 * @author bug菌
 * @Source 公众号：猿圈奇妙屋
 * @des： 【修建高铁最优成本or最优高铁城市修建方案(A卷-100分)】问题
 * @url： https://blog.csdn.net/weixin_43970743/article/details/146964930
 */
public class OdMain {
    public static void main(String[] args) {
        // 读取输入
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();  // 城市总数（编号从 0 到 n-1）
        int pair_count_1 = in.nextInt();  // 可选高铁线路的数量
        int pair_count_2 = in.nextInt();  // 必须修建的高铁线路数量

        // 存储可建设高铁的城市对和建设成本
        int[][] city_pair_1 = new int[pair_count_1][3];
        for (int i = 0; i < pair_count_1; i++) {
            city_pair_1[i][0] = in.nextInt();  // 城市1
            city_pair_1[i][1] = in.nextInt();  // 城市2
            city_pair_1[i][2] = in.nextInt();  // 建设成本
        }

        // 存储必须修建的高铁线路
        int[][] city_pair_2 = new int[pair_count_2][2];
        for (int i = 0; i < pair_count_2; i++) {
            city_pair_2[i][0] = in.nextInt();  // 城市1
            city_pair_2[i][1] = in.nextInt();  // 城市2
        }

        // 初始化并查集，用于连通判断
        UF uf = new UF(n);

        // 用 HashMap 存储城市对和其对应的费用，key格式为 "小编号-大编号"
        HashMap<String, Integer> city_map = new HashMap<>();
        for (int[] city_pair : city_pair_1) {
            int city1 = city_pair[0], city2 = city_pair[1];
            String key = city1 < city2 ? city1 + "-" + city2 : city2 + "-" + city1;
            city_map.put(key, city_pair[2]);
        }

        // 先处理必须建设的线路
        int result = 0;
        for (int[] city_pair : city_pair_2) {
            int city1 = city_pair[0], city2 = city_pair[1];
            String key = city1 < city2 ? city1 + "-" + city2 : city2 + "-" + city1;

            // 加入费用
            result += city_map.get(key);

            // 把这两个城市并到一个集合
            uf.union(city1, city2);
        }

        // 如果已经所有城市连通，就直接返回总费用
        if (uf.count == 1) {
            System.out.println(result);
            return;
        }

        // 将可选的线路按建设费用从小到大排序
        Arrays.sort(city_pair_1, (a, b) -> a[2] - b[2]);

        // 逐条尝试修建可选线路（Kruskal思想）
        for (int[] city_pair : city_pair_1) {
            int city1 = city_pair[0], city2 = city_pair[1];

            // 如果这两个城市还没连通
            if (uf.find(city1) != uf.find(city2)) {
                uf.union(city1, city2);
                result += city_pair[2];
            }

            // 如果全部城市已连通，提前退出
            if (uf.count == 1) {
                break;
            }
        }

        // 如果还有城市不连通，说明无法构建完整网络
        if (uf.count > 1) {
            System.out.println(-1);
            return;
        }

        // 输出最小总成本
        System.out.println(result);
    }

    // 并查集结构，用于动态维护连接状态
    static class UF {
        int[] item;  // item[i] 表示城市i所在集合的代表元素
        int count;   // 当前有多少个连通分量

        public UF(int n) {
            item = new int[n + 1]; // 支持编号到 n
            count = n;             // 初始每个城市独立
            for (int i = 0; i < n; i++) item[i] = i;
        }

        // 查找某个城市所在集合（带路径压缩）
        public int find(int x) {
            if (x != item[x]) {
                item[x] = find(item[x]); // 压缩路径
            }
            return item[x];
        }

        // 合并两个集合
        public void union(int x, int y) {
            int x_root = find(x);
            int y_root = find(y);

            if (x_root != y_root) {
                item[y_root] = x_root;  // 合并
                count--;                // 连通分量减少
            }
        }
    }
}